home *** CD-ROM | disk | FTP | other *** search
/ Language/OS - Multiplatform Resource Library / LANGUAGE OS.iso / cpp_libs / intrvews / xgrab.lha / xgrab / grabst / copy.c < prev    next >
C/C++ Source or Header  |  1990-03-06  |  6KB  |  276 lines
  1. /**
  2.    GRAB Graph Layout and Browser System
  3.  
  4.    Copyright (c) 1986, 1988 Regents of the University of California
  5.    Copyright (c) 1989, Tera Computer Company
  6.  **/
  7.  
  8.   /** 
  9.      copy.c -- routines to copy parts of the digraph data structure 
  10.    **/
  11.  
  12. #include "malloc.h"
  13. #include "attribute.h"
  14. #include "digraph.h"
  15.  
  16. char **copy_attr();
  17. INEDGE *copy_in_edges();
  18. OUTEDGE *copy_out_edges();
  19. VERTEX *insert_vertex();
  20. LEVEL *copy_levels();
  21.  
  22. NODE *copy_node(digraph, node)
  23. DIGRAPH *digraph;
  24. NODE *node;
  25.   /**
  26.      copy_node makes a copy of the node and returns it.
  27.      digraph should be the *new node's* digraph.
  28.    **/
  29. {
  30.     NODE *n;
  31.  
  32.     if (node == NULL)
  33.     {
  34.     return NULL;
  35.     }
  36.     else
  37.     {
  38.         new(n, NODE);
  39.         n->coalescer_vno = node->coalescer_vno;
  40.     n->coalesced = node->coalesced;
  41.     n->coalescer = node->coalescer;
  42.         n->out_edges = copy_out_edges(digraph, node);
  43.         n->in_edges = copy_in_edges(node);
  44.         n->attributes = copy_attr(node->attributes, NNodeAttr(digraph));
  45.     
  46.     init_set(Expansion(n));
  47.         copy_set(Expansion(n), Expansion(node));
  48.         init_set(Succ_set(n));
  49.         copy_set(Succ_set(n), Succ_set(node));
  50.         init_set(Ante_set(n));
  51.         copy_set(Ante_set(n), Ante_set(node));
  52.         copy_member(Node_member(n), Node_member(node));
  53.     
  54.         X_position(n) = X_position(node);
  55.         Y_position(n) = Y_position(node);
  56.         Shape(n) = Shape(node);
  57.         Brush(n) = Brush(node);
  58.         Color(n) = Color(node);
  59.     Displayed(n) = Displayed(node);
  60.         Half_width(n) = Half_width(node);
  61.         Half_height(n) = Half_height(node);
  62.         n->vertex = insert_vertex(digraph, Name(node));
  63.     Vno(n) = Vno(node);
  64.     
  65.         return n;
  66.     }
  67. } /* copy_node */
  68.  
  69. char **copy_attr(attr, num)
  70. char **attr;
  71. int num;
  72.   /** 
  73.      copy_attr copies *any* array of character pointers of length num and 
  74.      returns the copy.  Its used primarily to copy node or edge attributes
  75.    **/
  76. {
  77.     int i;
  78.     char **a;
  79.  
  80.     a = (char **) malloc(sizeof(char *) * num);
  81.  
  82.     for (i = 0; i < num; i++)
  83.     {
  84.     strsave(a[i], attr[i]);
  85.     }
  86.  
  87.     return a;
  88. }
  89.  
  90. copy_member(m, member)
  91. MEMBER *m, *member;
  92.   /**
  93.      copy the "member" fields of a node
  94.    **/
  95. {
  96.     Last_dummy(m) = Last_dummy(member);
  97.     Level_no(m) = Level_no(member);
  98.     Position(m) = Position(member);
  99.     Status(m) = Status(member);
  100.     Is_layed(m) = Is_layed(member);
  101.     Bc(m, UP) = Bc(member, UP);
  102.     Bc(m, DOWN) = Bc(member, DOWN);
  103.     Priority(m, UP) = Priority(member, UP);
  104.     Priority(m, DOWN) = Priority(member, DOWN);
  105.       /* the following fields are set when levels are assigned */
  106.     Prev_member(m) = Next_member(m) = NULL;
  107. }
  108.  
  109. OUTEDGE *copy_out_edges(digraph, node)
  110. DIGRAPH *digraph;
  111. NODE *node;
  112.   /**
  113.      make a copy of the out edges of a node.  For this to work, the vno's
  114.      of digraph must correspond exactly to the vno's of the old digraph
  115.    **/
  116. {
  117.     OUTEDGE *edge, *e, *t;
  118.  
  119.     e = NULL;
  120.  
  121.     all_out_edges(node, edge)
  122.     loop
  123.     new(t, OUTEDGE);
  124.     t->next = e;
  125.     e = t;
  126.  
  127.     Brush(t) = Brush(edge);
  128.     Color(t) = Color(edge);
  129.     Ord(t) = Ord(edge);
  130.     t->attributes = copy_attr(edge->attributes, NEdgeAttr(digraph));
  131.     t->edge_reversed = edge->edge_reversed;
  132.     t->to_vno = edge->to_vno;
  133.     endloop
  134.  
  135.     return e;
  136. } /* copy_out_edges */
  137.  
  138. INEDGE *copy_in_edges(node)
  139. NODE *node;
  140.   /**
  141.      make a copy of the out edges of a node.  For this to work, the vno's
  142.      of the new digraph must correspond exactly to the vno's of the old 
  143.      digraph
  144.    **/
  145. {
  146.     INEDGE *edge, *e, *t;
  147.  
  148.     e = NULL;
  149.  
  150.     all_in_edges(node, edge)
  151.     loop
  152.     new(t, INEDGE);
  153.     t->next = e;
  154.     e = t;
  155.  
  156.     Ord(t) = Ord(edge);
  157.     t->edge_reversed = edge->edge_reversed;
  158.     t->from_vno = edge->from_vno;
  159.     endloop;
  160.  
  161.     return e;
  162. } /* copy_in_edges */
  163.  
  164. DIGRAPH *copy_digraph(digraph)
  165. DIGRAPH *digraph;
  166.   /** 
  167.      copy_digraph steps through a digraph and creates a new copy of it.
  168.    **/
  169. {
  170.     int i;
  171.     DIGRAPH *d;
  172.  
  173.     if (digraph == NULL)
  174.     {
  175.         return NULL;
  176.     }
  177.  
  178.     new(d, DIGRAPH);
  179.     strsave(d->title, Title(digraph));
  180.  
  181.     d->lastnode = digraph->lastnode;
  182.  
  183.     d->num_node_attributes = digraph->num_node_attributes;
  184.     d->num_edge_attributes = digraph->num_edge_attributes;
  185.     d->dist_node_attribute = digraph->dist_node_attribute;
  186.     d->dist_edge_attribute = digraph->dist_edge_attribute;
  187.       /* what a cheap trick! */
  188.     d->node_att_names = copy_attr(digraph->node_att_names, NNodeAttr(digraph));
  189.     d->edge_att_names = copy_attr(digraph->edge_att_names, NEdgeAttr(digraph));
  190.  
  191.       /** 
  192.      zero the hash table.  It will be properly filled by the 
  193.          insert_vertex calls in copy_node
  194.        **/
  195.     for (i = 0; i < MAXHASH; i++)
  196.     {
  197.     d->hashtbl[i] = NULL;
  198.     }
  199.  
  200.     for (i = 0; i < MAXNODES; i++)
  201.     {
  202.     d->nodes[i] = copy_node(d, digraph->nodes[i]);
  203.     }
  204.  
  205.     d->levels = copy_levels(d, digraph);
  206.  
  207.     return d;
  208. } /* copy_digraph */
  209.  
  210. LEVEL *copy_levels(digraph, digraph2)
  211. DIGRAPH *digraph, *digraph2;
  212.   /** 
  213.      copy_levels copies the levels of digraph2 to digraph, and, as a side 
  214.      effect, sets the Prev_member and Next_member values of the nodes to their
  215.      proper values
  216.    **/
  217. {
  218.     LEVEL *level, *l, *t;
  219.     MEMBER *m, *tmp, *last;
  220.     VNO vno;
  221.  
  222.     l = NULL;
  223.     digraph->lastlevel = l;
  224.  
  225.     each_level(digraph2, level)
  226.     loop
  227.     new(t, LEVEL);
  228.  
  229.     t->prev = digraph->lastlevel;
  230.     t->next = NULL;
  231.  
  232.     if (l == NULL)
  233.     {
  234.         l = t;
  235.     }
  236.     else
  237.     {
  238.         digraph->lastlevel->next = t;
  239.     }
  240.  
  241.     digraph->lastlevel = t;
  242.  
  243.     Lno(t) = Lno(level);
  244.     Num_cross(t) = Num_cross(level);
  245.     Offset(t) = Offset(level);
  246.     init_set(Members(t));
  247.     copy_set(Members(t), Members(level));
  248.  
  249.     m = NULL;
  250.     last = NULL;
  251.  
  252.       /* Set the next and prev member fields to their proper values */
  253.     each_element(Members(level), vno)
  254.     loop
  255.         tmp = Member(digraph, vno);
  256.         tmp->prev = last;
  257.         tmp->next = NULL;
  258.  
  259.         if (m == NULL)
  260.         {
  261.         m = tmp;
  262.         }
  263.         else
  264.         {
  265.         last->next = tmp;
  266.         }
  267.  
  268.         last = tmp;
  269.     endloop;
  270.  
  271.     Order(t) = m;
  272.     endloop;
  273.  
  274.     return l;
  275. }
  276.